import axios from 'axios'
import { config } from '../config'

// 创建API客户端
const apiClient = axios.create({
  baseURL: config.API_BASE_URL,
  timeout: config.API_TIMEOUT,
  headers: {
    'Content-Type': 'application/json'
  }
})

// 请求去重缓存
const pendingRequests = new Map()
const REQUEST_DEBOUNCE_TIME = 300 // 300ms内的重复请求会被合并

// 请求拦截器 - 添加认证token和去重逻辑
apiClient.interceptors.request.use(
  config => {
    // 添加认证token
    const token = localStorage.getItem('token')
    if (token) {
      config.headers.Authorization = `Bearer ${token}`
    }
    
    // 请求去重：对于GET请求，如果相同URL在短时间内重复请求，阻止重复请求
    if (config.method === 'get' || config.method === 'GET') {
      const requestKey = `${config.method}:${config.url}:${JSON.stringify(config.params || {})}`
      const cached = pendingRequests.get(requestKey)
      if (cached && Date.now() - cached.timestamp < REQUEST_DEBOUNCE_TIME) {
        console.log('🔄 请求去重，阻止重复请求:', requestKey)
        // 使用CancelToken取消请求
        const CancelToken = axios.CancelToken
        const source = CancelToken.source()
        source.cancel('DUPLICATE_REQUEST')
        config.cancelToken = source.token
      } else {
        pendingRequests.set(requestKey, { timestamp: Date.now() })
        
        // 清理过期的缓存
        setTimeout(() => {
          pendingRequests.delete(requestKey)
        }, REQUEST_DEBOUNCE_TIME * 2)
      }
    }
    
    return config
  },
  error => {
    return Promise.reject(error)
  }
)

// 响应拦截器 - 处理错误和429重试
apiClient.interceptors.response.use(
  response => {
    return response.data
  },
  async error => {
    // 如果是去重请求或被取消的请求，静默忽略
    if (axios.isCancel(error) || error.message === 'DUPLICATE_REQUEST') {
      console.log('🔄 请求已去重或被取消，忽略')
      return Promise.reject(error)
    }
    
    console.error('User API Error:', error)
    
    // 429错误处理 - 请求过于频繁
    if (error.response?.status === 429) {
      const retryAfter = parseInt(error.response.headers['retry-after']) || 5 // 默认5秒后重试
      console.warn(`⚠️ 请求过于频繁，${retryAfter}秒后重试...`)
      
      // 等待后自动重试（仅重试一次）
      if (!error.config._retry) {
        error.config._retry = true
        await new Promise(resolve => setTimeout(resolve, retryAfter * 1000))
        console.log('🔄 开始重试请求...')
        return apiClient.request(error.config)
      } else {
        const errorMessage = error.response?.data?.message || '请求过于频繁，请稍后再试'
        console.error('❌ 重试后仍然失败:', errorMessage)
        throw new Error(errorMessage)
      }
    }
    
    // 认证错误处理
    if (error.response?.status === 401) {
      localStorage.removeItem('token')
      localStorage.removeItem('user_info')
    }
    
    return Promise.reject(error)
  }
)

// 权限定义
export const PERMISSIONS = {
  TICKET_READ: 'ticket:read',
  TICKET_CREATE: 'ticket:create',
  TICKET_UPDATE: 'ticket:update',
  TICKET_DELETE: 'ticket:delete',
  TICKET_ASSIGN: 'ticket:assign',
  USER_MANAGE: 'user:manage',
  SYSTEM_CONFIG: 'system:config',
  REPORT_VIEW: 'report:view'
}

// 角色定义
export const ROLES = {
  ADMIN: 'admin',
  AGENT: 'agent',
  CUSTOMER: 'customer',
  MANAGER: 'manager'
}

// 角色权限映射
const ROLE_PERMISSIONS = {
  [ROLES.ADMIN]: [
    PERMISSIONS.TICKET_READ,
    PERMISSIONS.TICKET_CREATE,
    PERMISSIONS.TICKET_UPDATE,
    PERMISSIONS.TICKET_DELETE,
    PERMISSIONS.TICKET_ASSIGN,
    PERMISSIONS.USER_MANAGE,
    PERMISSIONS.SYSTEM_CONFIG,
    PERMISSIONS.REPORT_VIEW
  ],
  [ROLES.MANAGER]: [
    PERMISSIONS.TICKET_READ,
    PERMISSIONS.TICKET_CREATE,
    PERMISSIONS.TICKET_UPDATE,
    PERMISSIONS.TICKET_ASSIGN,
    PERMISSIONS.REPORT_VIEW
  ],
  [ROLES.AGENT]: [
    PERMISSIONS.TICKET_READ,
    PERMISSIONS.TICKET_CREATE,
    PERMISSIONS.TICKET_UPDATE,
    PERMISSIONS.TICKET_ASSIGN
  ],
  [ROLES.CUSTOMER]: [
    PERMISSIONS.TICKET_READ,
    PERMISSIONS.TICKET_CREATE
  ]
}

export const UserService = {
  // 获取用户列表
  async listUsers(params = {}) {
    try {
      console.log('📤 获取用户列表，参数:', params)
      const response = await apiClient.get('/users', { params })
      
      console.log('📥 用户列表响应:', response)
      
      // 处理响应格式：可能是分页数据 {content: [], totalElements: 0} 或 {success: true, data: {...}}
      if (response && response.success !== undefined) {
        if (response.success) {
          // 如果是分页响应
          if (response.data && response.data.content) {
            console.log('✅ 获取用户列表成功，数量:', response.data.content.length)
            return response.data.content || []
          } else if (Array.isArray(response.data)) {
            console.log('✅ 获取用户列表成功，数量:', response.data.length)
            return response.data
          } else {
            return []
          }
        } else {
          throw new Error(response.message || '获取用户列表失败')
        }
      } else if (response && response.content) {
        // 直接是分页格式
        console.log('✅ 获取用户列表成功，数量:', response.content.length)
        return response.content || []
      } else if (Array.isArray(response)) {
        // 直接是数组
        console.log('✅ 获取用户列表成功，数量:', response.length)
        return response
      } else {
        console.warn('⚠️ 用户列表响应格式未知:', response)
        return []
      }
    } catch (error) {
      console.error('❌ 获取用户列表失败:', error)
      // 提取更详细的错误信息
      if (error.response?.data) {
        const errorData = error.response.data
        if (errorData.message) {
          throw new Error(errorData.message)
        }
      }
      throw error
    }
  },

  // 创建用户
  async createUser(userData) {
    try {
      console.log('📤 发送创建用户请求:', userData)
      const response = await apiClient.post('/users', userData)
      
      console.log('📥 创建用户响应:', response)
      
      // 处理响应格式：response可能是 {success: true, data: {...}} 或直接是数据
      // 注意：响应拦截器已经返回了 response.data，所以这里response就是ApiResponse对象
      if (response && response.success !== undefined) {
        if (response.success) {
          console.log('✅ 创建用户成功，用户数据:', response.data)
          // response.data 就是 UserDto
          return response.data
        } else {
          throw new Error(response.message || '创建用户失败')
        }
      } else if (response && response.data) {
        // 如果响应直接包含data字段
        console.log('✅ 创建用户成功，用户数据:', response.data)
        return response.data
      } else if (response && (response.id || response.username)) {
        // 如果响应就是用户数据（直接是UserDto）
        console.log('✅ 创建用户成功，用户数据:', response)
        return response
      } else {
        console.warn('⚠️ 创建用户响应格式未知:', response)
        throw new Error('创建用户成功，但响应格式异常')
      }
    } catch (error) {
      console.error('❌ 创建用户失败:', error)
      console.error('❌ 错误响应数据:', error.response?.data)
      
      // 提取更详细的错误信息
      if (error.response?.data) {
        const errorData = error.response.data
        console.error('❌ 错误数据结构:', JSON.stringify(errorData, null, 2))
        
        // 如果有详细的验证错误信息（在data字段中）
        if (errorData.data && typeof errorData.data === 'object') {
          const validationErrors = Object.entries(errorData.data)
            .map(([field, message]) => `${field}: ${message}`)
            .join('; ')
          console.error('❌ 验证错误详情:', validationErrors)
          throw new Error(`参数验证失败: ${validationErrors}`)
        }
        
        // 检查message字段
        if (errorData.message) {
          console.error('❌ 错误消息:', errorData.message)
          throw new Error(errorData.message)
        } else if (errorData.error) {
          console.error('❌ 错误:', errorData.error)
          throw new Error(errorData.error)
        }
      }
      throw error
    }
  },

  // 更新用户
  async updateUser(userId, userData) {
    try {
      const response = await apiClient.put(`/users/${userId}`, userData)
      
      if (response.success) {
        console.log('✅ 更新用户成功')
        return response.data
      } else {
        throw new Error(response.message || '更新用户失败')
      }
    } catch (error) {
      console.error('❌ 更新用户失败:', error)
      throw error
    }
  },

  // 删除用户
  async deleteUser(userId) {
    try {
      const response = await apiClient.delete(`/users/${userId}`)
      
      if (response.success) {
        console.log('✅ 删除用户成功')
        return response.data
      } else {
        throw new Error(response.message || '删除用户失败')
      }
    } catch (error) {
      console.error('❌ 删除用户失败:', error)
      throw error
    }
  },

  // 更新用户权限
  async updatePermissions(userId, permissions) {
    try {
      const response = await apiClient.put(`/users/${userId}/permissions`, { permissions })
      
      if (response.success) {
        console.log('✅ 更新用户权限成功')
        return response.data
      } else {
        throw new Error(response.message || '更新用户权限失败')
      }
    } catch (error) {
      console.error('❌ 更新用户权限失败:', error)
      throw error
    }
  },

  // 获取用户详情
  async getUserById(userId) {
    try {
      const response = await apiClient.get(`/users/${userId}`)
      
      if (response.success) {
        console.log('✅ 获取用户详情成功')
        return response.data
      } else {
        throw new Error(response.message || '获取用户详情失败')
      }
    } catch (error) {
      console.error('❌ 获取用户详情失败:', error)
      throw error
    }
  },

  // 批量操作API方法
  async batchUpdateRole(userIds, role) {
    try {
      const response = await apiClient.post('/users/batch/role', {
        userIds,
        role
      })
      
      if (response.success) {
        console.log('✅ 批量更新角色成功')
        return response.data
      } else {
        throw new Error(response.message || '批量更新角色失败')
      }
    } catch (error) {
      console.error('❌ 批量更新角色失败:', error)
      throw error
    }
  },

  async batchUpdateStatus(userIds, status) {
    try {
      const response = await apiClient.post('/users/batch/status', {
        userIds,
        status
      })
      
      if (response.success) {
        console.log('✅ 批量更新状态成功')
        return response.data
      } else {
        throw new Error(response.message || '批量更新状态失败')
      }
    } catch (error) {
      console.error('❌ 批量更新状态失败:', error)
      throw error
    }
  },

  async batchDelete(userIds) {
    try {
      const response = await apiClient.post('/users/batch/delete', {
        userIds
      })
      
      if (response.success) {
        console.log('✅ 批量删除成功')
        return response.data
      } else {
        throw new Error(response.message || '批量删除失败')
      }
    } catch (error) {
      console.error('❌ 批量删除失败:', error)
      throw error
    }
  },

  // 兼容旧版本的方法
  async listAgents() {
    try {
      // 使用 /api/users/role/AGENT 端点（注意使用大写），该端点所有角色都可以访问
      const response = await apiClient.get('/users/role/AGENT')
      
      if (response.success && response.data) {
        const users = response.data.content || response.data || []
        console.log('✅ 获取 AGENT 列表成功，数量:', users.length)
        return users.map(user => ({ 
          id: user.id, 
          name: user.fullName || user.username 
        }))
      } else {
        console.warn('⚠️ 获取 AGENT 列表响应格式异常')
        return []
      }
    } catch (error) {
      console.error('❌ 获取 AGENT 列表失败:', error)
      // 降级：返回空数组，不阻塞工单创建
      return []
    }
  }
}


